using System.Collections;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Channels;
//通过查看此文件，可快速重温一些忽略的核心知识。
namespace ConsoleApp13
{
    public class 面食
    {

    }

    public class 包子 : 面食
    {
        public static implicit operator 包子(馒头 name)
        {
            return new 包子();
        }


    }


    public class 馒头 : 面食
    {
        public static implicit operator 馒头(包子 name)
        {
            return new 馒头();
        }
    }
    class ProgramA
    {
        static void MainA(string[] args)
        {
            馒头 馒头 = new();
            包子 包子 = new();

            包子 = 馒头;

            }
    }


    public class 可遍历集2<T> : IEnumerable
    {
        public T[] 数组 = new T[100];
        public IEnumerator GetEnumerator()
        {
            foreach (var i in 数组)
            {
                yield return i;
            }
        }
    }

    public class 可遍历集<T> : IEnumerable, IEnumerator
    {
        public object Current
        {
            get { return 数组[已使用下标]; }
            private set { }
                }
        public int 已使用下标 = 0;
        public int 遍历下标 = 0;
        public T[] 数组 = new T[100];
        public void 加入(T 对象)
        {
            数组[已使用下标] = 对象;
            已使用下标++;
        }
        public void 清空() { 数组 = new T[100]; }
        public IEnumerator GetEnumerator()
        {
            return this;
        }

        public bool MoveNext()
        {
            遍历下标++;
            if (遍历下标 !< 数组.Length) { return false; }
            return 数组[遍历下标] != null ? true : false;
        }

        public void Reset()
        {
            遍历下标 = 0;
        }

        public void Foreach(Action<T> action)
        {
            for (int i = 0; i < 已使用下标; i++)
            {
                action(数组[i]);
            }
        }
    }

    public class 自定义特性:Attribute
    {
        public string 自定义特性名称 { get; set; }
        public 自定义特性(string 自定义特性名,[CallerLineNumber]int 调用者 = 0)
        {
            Console.WriteLine($"使用自定义特性 {自定义特性名} 来自 {调用者}行");
            自定义特性名称 = 自定义特性名;
        }
        public void 检测特性()
        {
            Console.WriteLine("检测了特性");
        }
    }

    public static class 初始
    {
        public static int a = 0;
        static 初始()
        {
            Console.WriteLine("应用程序初始化");
        }
        public static void 交换控制(this object console)
        {
            Console.WriteLine( "已切换控制");
        }
    }
    [自定义特性("周游的自定义")]
    public partial class 周游
    {
        public int 唯一值 = 0;
        public int[] 周游数 = new int[] { 1, 6, 5, 8, 7, 6 };
        public int this[int 索引]
        {
            get { 判断索引(索引); return 周游数[索引]; }
            set { 判断索引(索引); 周游数[索引] = value; }
        }
        
        public void 判断索引(int 索引)
        {
            if (索引 > 周游数.Length)  { throw new Exception("已经超出了最大的周游数", new StackOverflowException()); }
        }

        public static 周游 operator + (int 加数,周游 周游)
        {
            for (int i = 0; i < 周游.周游数.Length; i++) { 周游.周游数[i] += 加数; }
            return 周游;
        }

        public static 周游 operator +( 周游 周游,int 加数)
        {
            for (int i = 0; i < 周游.周游数.Length; i++) { 周游.周游数[i] += 加数; }
            return 周游;
        }
        public 周游 克隆()
        {
            return (周游)this.MemberwiseClone();
        }
    }

    public partial class 周游 { public int  测试() { Console.WriteLine( "已测试");  return 0; }  }

    public class Myclass
    {
        public int a { get; set; } = 75;
        public string b { get; set; } = 25.ToString();
        public Myclass(int a, string b)
        {
            Console.WriteLine("子的构造函数已启动");
        }

        public Myclass()
        {
            Console.WriteLine("通用的构造函数已启动");
        }
    }
    
    internal class Program
    {
       
        static void 数组元素交换(int[] 数组, int 元素序号A, int 元素序号B)
        {
            StringBuilder 数字交换提示 = new StringBuilder();
            数字交换提示.Append($"已从 {数组[元素序号A]} {数组[元素序号B]} ->");
            数组[元素序号A] = 数组[元素序号B] + 数组[元素序号A];
            数组[元素序号B] = 数组[元素序号A] - 数组[元素序号B];
            数组[元素序号A] = 数组[元素序号A] - 数组[元素序号B];
            数字交换提示.Append($"{数组[元素序号A]} {数组[元素序号B]}");
            Console.WriteLine(数字交换提示.ToString());
        }
        static void Main(string[] args)
        {
            周游 周游 = new 周游();
            周游.唯一值 = 7;
            var 克隆周游 = 周游.克隆();
            周游.唯一值 = 9;
            Console.WriteLine(周游[1]);
            Random c = new Random();
            c.交换控制();
            int a = 6;
            a.交换控制();
            var 新周游 =周游+a;
            Console.WriteLine(周游[1]);
            Console.WriteLine(克隆周游[1]);
            Console.WriteLine(周游.唯一值);
            Console.WriteLine(克隆周游.唯一值);
            Console.WriteLine(克隆周游[1]);
            周游.测试();
            var 类型 = 周游.GetType();
            var 是否继承特性 = 类型.IsDefined(typeof(自定义特性), false); Console.WriteLine(是否继承特性);
            var 特性组 = 类型.GetCustomAttributes(typeof(自定义特性),true);
            特性组.Any((x) => {
                var y = x as 自定义特性;
                Console.WriteLine(y.自定义特性名称) ;
                y.检测特性();
                return false;
            });
            可遍历集<string> 遍历集 = new 可遍历集<string>();
            遍历集.加入("对象1");
            遍历集.加入("对象2");
            遍历集.加入("对象3");
            遍历集.Foreach(x => Console.WriteLine(x));
            可遍历集2<int> 遍历集2 = new();
            foreach (var item in 遍历集2)
            {
                Console.WriteLine(item);
            }

        }

        private static void 选择排序(int[] 数组)
        {
            for (int i = 0; i < 数组.Length; i++)
            {
                if (数组.Length < 2) { break; }
                if (i + 1 > 数组.Length - 1) { continue; }
                for (int j = i; j < 数组.Length; j++)
                {
                    var 最小值 = 数组[i]; var 最小值位置 = i;
                    if (数组[j] < 最小值) { 最小值 = 数组[j]; 最小值位置 = j; 数组元素交换(数组, i, j); }
                }


            }
        }

        private static void NewMethod(int[] 数组)
        {
            int 交换次数 = 0;
            int 循环次数 = -1;
            do
            {
                循环次数++;
                交换次数 = 0;
                for (int i = 0; i < 数组.Length; i++)
                {

                    if (数组.Length < 2) { break; }
                    if (i + 1 > 数组.Length - 1) { continue; }
                    if (数组[i] > 数组[i + 1]) { 数组元素交换(数组, i, i + 1); 交换次数++; }

                }
            }
            while (交换次数 != 0);
            Console.WriteLine($"排序完毕，共执行{循环次数}次");
        }
    }
}